package com.sweetcircle.utils;

import jakarta.annotation.Resource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.time.Duration;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;


@Component
public class RedisUtils<V> {

    private static final Logger logger = LoggerFactory.getLogger(RedisUtils.class);
    @Resource
    private RedisTemplate<String, V> redisTemplate;


    /**
     * 判断缓存是否存在
     *
     * @param key 缓存key
     * @return 缓存是否存在
     */
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 缓存数据
     *
     * @param key   缓存key
     * @param value 缓存值
     */
    public boolean set(String key, V value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            logger.error("设置redisKey:{},value:{}失败", key, value);
            return false;
        }
    }

    /**
     * 缓存数据
     *
     * @param key   缓存key
     * @param value 缓存值
     * @param time  缓存失效时间，单位：秒
     */
    public boolean set(String key, V value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            logger.error("设置redisKey:{},value:{}失败", key, value);
            return false;
        }
    }

    public boolean set(String key, V value, long time, TimeUnit timeUnit) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, timeUnit);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            logger.error("设置redisKey:{},value:{}失败", key, value);
            return false;
        }
    }

    /**
     * 缓存数据
     *
     * @param key   缓存key
     * @param value 缓存值
     * @param time  缓存失效时间，单位：秒
     */
    public boolean set(String key, V value, Duration time) {
        try {
            if (time != null) {
                redisTemplate.opsForValue().set(key, value, time);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            logger.error("设置redisKey:{},value:{}失败", key, value);
            return false;
        }
    }

    /**
     * 获取缓存
     *
     * @param key 缓存key
     * @return 缓存值
     */
    public V get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 缓存失效时间设置
     *
     * @param key  缓存key
     * @param time 失效时间 ,单位s
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 缓存失效时间设置
     *
     * @param key  缓存key
     * @param date 失效时间
     */
    public boolean expireAt(String key, Date date) {
        try {
            if (date != null) {
                redisTemplate.expireAt(key, date);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     *
     * @param key 缓存key
     * @return 是否删除成功
     */
    public Boolean delete(String key) {
        return redisTemplate.delete(key);
    }

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    public void delete(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
            }
        }
    }

    public List<V> getQueueList(String key) {
        return redisTemplate.opsForList().range(key, 0, -1);
    }

    public boolean lpush(String key, V value, long time) {
        try {
            redisTemplate.opsForList().leftPush(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    public long remove(String key, V value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, 1, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    public boolean lpushAll(String key, List<V> values, long time) {
        try {
            redisTemplate.opsForList().leftPushAll(key, values);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 计数器加1
     *
     * @param key
     * @return
     */
    public Long increment(String key) {
        return redisTemplate.opsForValue().increment(key);
    }

    /**
     * 计数器以指定步长递增
     *
     * @param key   计数器key
     * @param delta 自增步长
     * @return
     */
    public Long increment(String key, long delta) {
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 计数器以指定步长递增
     *
     * @param key   计数器key
     * @param delta 自增步长
     * @return
     */
    public Double increment(String key, double delta) {
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * hash中field对应计数器加值
     *
     * @param key
     * @param field
     * @param delta
     * @return
     */
    public Long hashIncrement(String key, String field, long delta) {
        return redisTemplate.opsForHash().increment(key, field, delta);
    }

    /**
     * 计数器减1
     *
     * @param key
     * @return
     */
    public Long decrement(String key) {
        return redisTemplate.opsForValue().decrement(key);
    }

    /**
     * 计数器以指定步长递减
     *
     * @param key   计数器key
     * @param delta 递减步长
     * @return
     */
    public Long decrement(String key, long delta) {
        return redisTemplate.opsForValue().decrement(key, delta);
    }


    /**
     * 从队列右边移除一个元素并返回该元素
     *
     * @param key
     * @return java.lang.Object
     * @author zhanglihui
     * @date 2020-11-06 10:42
     */
    public V rightPop(String key) {
        return redisTemplate.opsForList().rightPop(key);
    }

    /**
     * 往列表尾部插入一个元素
     *
     * @param key
     * @param value
     */
    public void rightPush(String key, V value) {
        redisTemplate.opsForList().rightPush(key, value);
    }

    /**
     * 从队列尾部插入多个元素
     *
     * @param key    键值
     * @param values 插入元素列表
     * @return 插入个数
     */
    public Long rightPushAll(String key, V... values) {
        return redisTemplate.opsForList().rightPushAll(key, values);
    }

    /**
     * 移除并获取列表头部第一个元素
     *
     * @param key
     * @return
     */
    public V leftPop(String key) {
        return redisTemplate.opsForList().leftPop(key);
    }

    /**
     * 从队列左边插入一个元素
     *
     * @param key   键值
     * @param value 插入元素
     * @return 插入个数
     * @author zhanglihui
     * @date 2020-11-06 10:42
     */
    public Long leftPush(String key, V value) {
        return redisTemplate.opsForList().leftPush(key, value);
    }

    /**
     * 从队列左边插入多个元素
     *
     * @param key    键值
     * @param values 插入元素列表
     * @return 插入个数
     */
    public Long leftPushAll(String key, V... values) {
        return redisTemplate.opsForList().leftPushAll(key, values);
    }

    /**
     * 获取列表长度
     *
     * @param key
     * @return java.lang.Long
     * @author zhanglihui
     * @date 2020-11-06 10:46
     */
    public Long listSize(String key) {
        return redisTemplate.opsForList().size(key);
    }

    /**
     * 获取列表中的数据
     *
     * @param key   缓存值
     * @param start list开始下标
     * @param end   list结束下标，-1代表末尾
     * @return java.util.List<java.lang.Object>
     * @author zhanglihui
     * @date 2020-11-06 10:47
     */
    public List<V> listRange(String key, int start, int end) {
        return redisTemplate.opsForList().range(key, start, end);
    }

    /**
     * 保留指定区间内元素，其余元素都将被删除
     *
     * @param key   list key
     * @param start 开始下标
     * @param end   结束下标
     */
    public void listTrim(String key, int start, int end) {
        redisTemplate.opsForList().trim(key, start, end);
    }

    /**
     * 批量查询
     *
     * @param keys 查询主键列表
     */
    public List<V> multiGet(List<String> keys) {
        return redisTemplate.opsForValue().multiGet(keys);
    }

    /**
     * 将member元素添加到有序集key中，按score排序
     *
     * @param key    有序集
     * @param member 有续集的成员
     * @param score  有序集的排序值
     * @return 是否添加成功
     */
    public Boolean zAdd(String key, V member, double score) {
        return redisTemplate.opsForZSet().add(key, member, score);
    }

    /**
     * 批量添加元素到有序集key中
     *
     * @param key    有序集
     * @param tuples 元素列表
     * @return 添加数量
     */
    public Long zAdd(String key, Set<ZSetOperations.TypedTuple<V>> tuples) {
        return redisTemplate.opsForZSet().add(key, tuples);
    }

    /**
     * 返回有序集 key 中，指定区间内的成员。
     *
     * @param key   有序集
     * @param start 下标起始位置，从0开始
     * @param end   下标结束位置，-1表示最后一个
     * @return 有序集列表
     */
    public Set<ZSetOperations.TypedTuple<V>> zRange(String key, long start, long end) {
        return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
    }

    /**
     * 根据设置的score获取区间值
     *
     * @param key 有序集
     * @param min score起始值
     * @param max score结束值
     * @return 有序区间值
     */
    public Set<ZSetOperations.TypedTuple<V>> zRangeByScore(String key, double min, double max) {
        return redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max);
    }

    /**
     * 根据设置的score获取区间值
     *
     * @param key    有序集
     * @param min    score起始值
     * @param max    score结束值
     * @param offset 偏移值
     * @param count  返回数量
     * @return 有序区间值
     */
    public Set<ZSetOperations.TypedTuple<V>> zRangeByScore(String key, double min, double max, int offset, int count) {
        return redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max, offset, count);
    }

    /**
     * 移除有序集 key 中，所有 score 值介于 min 和 max 之间
     *
     * @param key 有序集
     * @param min score最小值
     * @param max score最大值
     * @return 删除条数
     */
    public Long removeByScore(String key, double min, double max) {
        return redisTemplate.opsForZSet().removeRangeByScore(key, min, max);
    }

    /**
     * 删除zset中的某个元素
     *
     * @param key    有序集
     * @param values 元素
     * @return 删除条数
     */
    public Long zSetRemove(String key, V... values) {
        return redisTemplate.opsForZSet().remove(key, values);
    }

    /**
     * 根据score范围查询元素，倒序排序
     *
     * @param key    有序集
     * @param min    score最小值
     * @param max    score最大值
     * @param offset 偏移量
     * @param count  返回数量
     * @return Set<ZSetOperations.TypedTuple < Object>>
     */
    public Set<ZSetOperations.TypedTuple<V>> zReverseRangeByScoreWithScores(String key, double min, double max, long offset, long count) {
        return redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key, min, max, offset, count);
    }

    /**
     * 根据score范围查询元素，倒序排序
     *
     * @param key 有序集
     * @param min score最小值
     * @param max score最大值
     * @return Set<ZSetOperations.TypedTuple < Object>>
     */
    public Set<ZSetOperations.TypedTuple<V>> zReverseRangeByScoreWithScores(String key, double min, double max) {
        return redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key, min, max);
    }

    /**
     * zset根据下标倒序查询
     *
     * @param key   缓存key
     * @param start 开始下标
     * @param end   结束下标
     * @return
     */
    public Set<ZSetOperations.TypedTuple<V>> zReverseRangeByScore(String key, long start, long end) {
        return redisTemplate.opsForZSet().reverseRangeWithScores(key, start, end);
    }


    /**
     * 获取元素的分值
     *
     * @param key   有序集
     * @param value 元素
     * @return 分值
     */
    public Double score(String key, V value) {
        return redisTemplate.opsForZSet().score(key, value);
    }

    /**
     * 指定元素增加score
     *
     * @param key   有序集
     * @param value 元素
     * @param delta 增加值
     * @return score
     */
    public Double incrementScore(String key, V value, double delta) {
        return redisTemplate.opsForZSet().incrementScore(key, value, delta);
    }

    /**
     * 查询zset大小
     *
     * @param key 有序集
     * @return zset元素数量
     */
    public Long zSize(String key) {
        return redisTemplate.opsForZSet().size(key);
    }

    /**
     * 根据score范围查询数量
     *
     * @param key 有序集
     * @param min score最小值
     * @param max score最大值
     * @return 统计数量
     */
    public Long zCount(String key, double min, double max) {
        return redisTemplate.opsForZSet().count(key, min, max);
    }

    /**
     * 根据参数 count 的值，移除列表中与参数 delta 相等的元素。
     *
     * @param key   队列
     * @param count count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 COUNT 。
     *              count < 0 : 从表尾开始向表头搜索，移除与 VALUE 相等的元素，数量为 COUNT 的绝对值。
     *              count = 0 : 移除表中所有与 VALUE 相等的值。
     * @param value 元素
     * @return
     */
    public Long listRem(String key, long count, V value) {
        return redisTemplate.opsForList().remove(key, count, value);
    }


    /**
     * 移除有序集中，指定排名(rank)区间内的所有成员。
     *
     * @param key   key
     * @param start 排名开始位置
     * @param end   排名结束位置
     * @return 被移除成员的数量
     */
    public Long zRemByRank(String key, long start, long end) {
        return redisTemplate.opsForZSet().removeRange(key, start, end);
    }

}
